package com.zshan.clinic.common.util.date;

import com.zshan.clinic.common.util.string.StringUtil;
import org.joda.time.DateTime;
import org.joda.time.Duration;
import org.joda.time.format.DateTimeFormat;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.*;

/**
 * 时间工具类
 */
public class DateTimeUtils {

    public static final String YYYYMMDD_HH_MM_SS = "yyyy/MM/dd HH:mm:ss";


    public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";

    public static final String YYYY_MM = "yyyy-MM";

    public static final String YYYY_MM_DD = "yyyy-MM-dd";

    public static final String YYYY = "yyyy";

    public static final String YYYYMMDD = "yyyyMMdd";

    public static final String YYYYMM = "yyyyMM";

    public static final String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";

    public static final String yyyy_mm_dd = "yyyy.MM.dd";

    public static final String YYYY_MM_DD_HH = "yyyy-MM-dd HH";

    public static final Map<Integer,String> weekMap = new HashMap<>();

    public static final String HHMM = "HH:mm";
    static {
        weekMap.put(1,"周一");
        weekMap.put(2,"周二");
        weekMap.put(3,"周三");
        weekMap.put(4,"周四");
        weekMap.put(5,"周五");
        weekMap.put(6,"周六");
        weekMap.put(0,"周日");
    }

    /**
     * 给指定日期减去指定天数
     * @param date 原始日期（如果为 null，则使用当前日期）
     * @param days 要减的天数（建议传正数；若为负数也按减去其绝对值处理）
     * @return 相减后的日期
     */
    public static LocalDate subDays(LocalDate date, int days) {
        if (date == null) {
            date = LocalDate.now();
        }
        return date.minusDays(Math.abs(days));
    }

    /**
     * 给指定日期加上（或减去）指定天数
     * @param date 原始日期（如果为 null，则使用当前日期）
     * @param days 要加的天数（可以为负数）
     * @return 加完后的日期
     */
    public static LocalDate addDays(LocalDate date, int days) {
        if (date == null) {
            date = LocalDate.now();
        }
        return date.plusDays(days);
    }

    public static LocalDate toLocalDate(Date date) {
        if (date == null) {
            return null;
        }
        return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
    }


    /**
     * 判断时间格式
     * @param dateStr
     * @return
     */
    public static boolean isValidLocalDate(String dateStr) {
        try {
            LocalDate.parse(dateStr); // 默认格式为 yyyy-MM-dd
            return true;
        } catch (Exception e) {
            return false;
        }
    }


    public static String getCurWeek() {
        DateTime dateTime = DateTime.now();
        int year = dateTime.getWeekyear();
        int week = dateTime.getWeekOfWeekyear();
        return week < 10 ? year + "0" + week : year + "" + week;
    }



    /**
     * 取两个时间中的较晚者（后面的时间）
     *
     * 用于求班次开始时间和固定时段开始时间的最大值，
     * 得到排班与时段的真正起始时间交集。
     *
     * @param t1 第一个时间
     * @param t2 第二个时间
     * @return 两个时间中较晚的时间
     */
    public static LocalTime max(LocalTime t1, LocalTime t2) {
        return t1.isAfter(t2) ? t1 : t2;
    }

    /**
     * 取两个时间中的较早者（前面的时间）
     *
     * 用于求班次结束时间和固定时段结束时间的最小值，
     * 得到排班与时段的真正结束时间交集。
     *
     * @param t1 第一个时间
     * @param t2 第二个时间
     * @return 两个时间中较早的时间
     */
    public static LocalTime min(LocalTime t1, LocalTime t2) {
        return t1.isBefore(t2) ? t1 : t2;
    }


    public static Date getMaxDate(){
        return DateTimeUtils.parseDate("20991231000000",DateTimeUtils.YYYYMMDDHHMMSS);
    }

    /**
     * 根据开始结束时间查询所有的日期
     *
     * @param beginDate
     * @param endDate
     * @return
     */
    public static List<Date> getDatesBetweenTwoDate(Date beginDate, Date endDate) {
        List<Date> lDate = new ArrayList<>();
        // 把开始时间加入集合
        lDate.add(beginDate);
        Calendar cal = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        cal.setTime(beginDate);
        boolean bContinue = true;
        while (bContinue) {
            // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
            cal.add(Calendar.DAY_OF_MONTH, 1);

            // 测试此日期是否在指定日期之后
            if (endDate.after(cal.getTime())) {
                lDate.add(cal.getTime());
            } else {
                break;
            }
        }
        // 把结束时间加入集合
        lDate.add(endDate);
        return lDate;
    }

    /**
     * 根据开始结束时间查询所有的日期
     *
     * @param beginDate
     * @param endDate
     * @return
     */
    public static Set<String> getDatesBetweenTwoDate(Date beginDate, Date endDate, String format) {
        Set<String> lDate = new LinkedHashSet<>();
        // 把开始时间加入集合
        lDate.add(getDateStr(beginDate, format));
        Calendar cal = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        cal.setTime(beginDate);
        boolean bContinue = true;
        while (bContinue) {
            // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
            cal.add(Calendar.DAY_OF_MONTH, 1);

            // 测试此日期是否在指定日期之后
            if (endDate.after(cal.getTime())) {
                lDate.add(getDateStr(cal.getTime(), format));
            } else {
                break;
            }
        }
        // 把结束时间加入集合
        lDate.add(getDateStr(endDate, format));
        return lDate;
    }

    /**
     * yyyy-MM-dd HH:mm:ss 日期转字符串
     *
     * @param date
     * @return
     */
    public static String getDateStr(Date date, String format) {
        String result = "";
        if (null != date) {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            result = sdf.format(date);
        }
        return result;
    }

    /**
     * 加天
     *
     * @param date
     * @param days
     * @return
     */
    public static DateTime plusDay(Date date, Integer days) {
        if (null == date) {
            return null;
        }
        return new DateTime(date).plusDays(days);
    }

    /**
     * 加天
     *
     * @param date
     * @param days
     * @return
     */
    public static Date plusDays(Date date, Integer days) {
        if (null == date) {
            return null;
        }
        return new DateTime(date).plusDays(days).toDate();
    }


    /**
     * 减天
     *
     * @param date
     * @param days
     * @return
     */
    public static DateTime minusDayToDateTime(Date date, Integer days) {
        if (null == date) {
            return null;
        }
        return new DateTime(date).minusDays(days);
    }

    /**
     * 减小时
     * @param date
     * @param hours
     * @return
     */
    public static Date minusHoursToDateTime(Date date, Integer hours) {
        if (null == date) {
            return null;
        }
        return new DateTime(date).minusHours(hours).toDate();
    }

    /**
     * 减天
     *
     * @param date
     * @param days
     * @return
     */
    public static Date minusDays(Date date, Integer days) {
        if (null == date) {
            return null;
        }
        return new DateTime(date).minusDays(days).toDate();
    }

    /**
     * 减天
     *
     * @param date
     * @param days
     * @return
     */
    public static String minusDay(Date date, Integer days) {
        if (null == date) {
            return null;
        }
        return new DateTime(date).minusDays(days).toString(YYYYMMDD);
    }

    /**
     * 日期加分钟
     *
     * @param date
     * @param seconds
     * @return
     */
    public static Date plusSeconds(Date date, Integer seconds) {
        if (null == date) {
            return null;
        }
        return new DateTime(date).plusSeconds(seconds).toDate();
    }

    /**
     * 日期加分钟
     *
     * @param date
     * @param minutes
     * @return
     */
    public static Date plusMinutes(Date date, Integer minutes) {
        if (null == date) {
            return null;
        }
        return new DateTime(date).plusMinutes(minutes).toDate();
    }

    /**
     * 日期减分钟
     *
     * @param date
     * @param minutes
     * @return
     */
    public static Date minusMinutes(Date date, Integer minutes) {
        if (null == date) {
            return null;
        }
        return new DateTime(date).minusMinutes(minutes).toDate();
    }


    /**
     * 日期加月份
     *
     * @param date
     * @param months
     * @return
     */
    public static Date plusMonths(Date date, Integer months) {
        if (null == date) {
            return null;
        }
        return new DateTime(date).plusMonths(months).toDate();
    }

    /**
     * 日期减月份
     *
     * @param date
     * @param months
     * @return
     */
    public static Date minusMonths(Date date, Integer months) {
        if (null == date) {
            return null;
        }
        return new DateTime(date).minusMonths(months).toDate();
    }

    /**
     * 判断两个日期是否在同一天
     *
     * @param dt1
     * @param dt2
     * @return
     */
    public static boolean isSameDay(DateTime dt1, DateTime dt2) {

        boolean res = false;
        Duration duration = new Duration(dt1, dt2);
        long intervalDays = duration.getStandardDays();  // 返回 long 类型
        if (intervalDays == 0) {
            res = true;
        }
        return res;
    }



    /**
     * 判断两个日期是否在同一天
     *
     * @param date
     * @param anotherDate
     * @return
     */
    public static boolean isSameDay(String date, String anotherDate) {

        boolean res = false;

        DateTime dt1 = new DateTime(date);
        DateTime dt2 = new DateTime(anotherDate);
        Duration duration = new Duration(dt1, dt2);
        long intervalDays = duration.getStandardDays();  // 返回 long 类型
        if (intervalDays == 0) {
            res = true;
        }
        return res;
    }

    /**
     * 判断两个日期是否为同一天
     * @param dt1
     * @param dt2
     * @return
     */
    public static boolean isSameDay(Date dt1, Date dt2) {

        boolean res = false;
        Duration duration = new Duration(new DateTime(dt1), new DateTime(dt2));
        long intervalDays = duration.getStandardDays();  // 返回 long 类型
        if (intervalDays == 0) {
            res = true;
        }
        return res;
    }

    /**
     * 获取当前系统时间
     *
     * @return
     */
    public static String getCurSysTime() {
        // 初始化时间
        DateTime dateTime = new DateTime();
        return dateTime.toString(YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 获取当前系统时间的年月
     *
     * @return
     */
    public static String getCurSysYearMonth() {

        // 初始化时间
        DateTime dateTime = new DateTime();
        return dateTime.toString(YYYY_MM);
    }

    /**
     * 获取当前系统年份
     *
     * @return
     */
    public static String getCurSysYear() {

        // 初始化时间
        DateTime dateTime = new DateTime();
        return dateTime.toString(YYYY);
    }

    /**
     * 将时间字符串转换成DateTime对象
     *
     * @param date
     * @return
     */
    public static Date str2DateTime(String date) {
        DateTime dateTime = null;
        if (StringUtil.isNotBlank(date)) {
            dateTime = DateTimeFormat.forPattern(YYYY_MM_DD_HH_MM_SS).parseDateTime(date);
            return dateTime.toDate();
        }
        return null;
    }


    /**
     * 将时间字符串转换成DateTime对象
     *
     * @param date
     * @return
     */
    public static DateTime str2DateTime(String date, String format) {
        DateTime dateTime = null;
        if (StringUtil.isNotBlank(date)) {
            dateTime = DateTimeFormat.forPattern(format).parseDateTime(date);
            return dateTime;
        }
        return null;
    }

    /**
     * 字符串转换为对应日期
     *
     * @param timeString
     * @param format
     * @return
     */
    public static Date stringToDate(String timeString, String format) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
        Date date = null;
        try {
            date = simpleDateFormat.parse(timeString);
        } catch (Exception e) {
        }
        return date;
    }

    /**
     * 当前时间的毫秒数
     *
     * @return
     */
    public static long timestamp() {

        DateTime dateTime = new DateTime();
        long millis = dateTime.getMillis();
        return millis;
    }

    /**
     * 日期转换为时间戳
     * @param date
     * @return
     */
    public static long timestamp(Date date) {

        DateTime dateTime = new DateTime(date);
        long millis = dateTime.getMillis();
        return millis;
    }



    /**
     * 比较两个日期的差距返回分钟数
     *
     * @param date1
     * @param date2
     * @return
     */
    public static Long minutesBetween(Date date1, Date date2) {
        DateTime dateTime1 = null;
        if (date1 != null) {
            dateTime1 = new DateTime(date1);
        }

        DateTime dateTime2 = null;
        if (date2 != null) {
            dateTime2 = new DateTime(date2);
        }
        Duration duration = new Duration(dateTime1, dateTime2);
        return duration.getStandardMinutes();  // 返回 long 类型
    }

    /**
     * 比较两个日期的差距返回分钟数
     *
     * @param date1 yyyy-MM-dd HH:mm:ss
     * @param date2
     * @return
     */
    public static Long secondsBetween(String date1, String date2) {
        DateTime dateTime1 = null;
        if (date1 != null) {
            dateTime1 = DateTimeFormat.forPattern(YYYY_MM_DD_HH_MM_SS).parseDateTime(date1);
        }

        DateTime dateTime2 = null;
        if (date2 != null) {
            dateTime2 = DateTimeFormat.forPattern(YYYY_MM_DD_HH_MM_SS).parseDateTime(date2);
        }
        Duration duration = new Duration(dateTime1, dateTime2);
        return duration.getStandardSeconds();  // 返回 long 类型
    }


    /**
     * 比较两个日期的差距返回秒
     * 如果date2大于date1返回的是正数
     * @param date1
     * @param date2
     * @return
     */
    public static Long secondsBetween(Date date1, Date date2) {
        DateTime dateTime1 = null;
        if (date1 != null) {
            dateTime1 = new DateTime(date1);
        }
        DateTime dateTime2 = null;
        if (date2 != null) {
            dateTime2 = new DateTime(date2);
        }
        Duration duration = new Duration(dateTime1, dateTime2);
        return duration.getStandardSeconds();  // 返回 long 类型
    }


    /**
     * 比较两个日期的差距返回天
     *
     * @param date1
     * @param date2
     * @return
     */
    public static Long daysBetween(Date date1, Date date2) {
        DateTime dateTime1 = null;
        if (date1 != null) {
            dateTime1 = new DateTime(date1);
        }

        DateTime dateTime2 = null;
        if (date2 != null) {
            dateTime2 = new DateTime(date2);
        }
        Duration duration = new Duration(dateTime1, dateTime2);
        return duration.getStandardDays();  // 返回 long 类型
    }

    public static String format(Date date) {

        return format(date, YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 日期格式化 日期格式为：yyyy-MM-dd
     *
     * @param date    日期
     * @param pattern 格式，如：DateUtils.DATE_TIME_PATTERN
     * @return 返回yyyy-MM-dd格式日期
     */
    public static String format(Date date, String pattern) {
        if (date != null) {
            DateTime dateTime = new DateTime(date);
            return dateTime.toString(pattern);
        }
        return null;
    }


    /**
     * 获取当月第一天  yyyy-MM-dd HH:mm:ss
     *
     * @param date
     * @return
     */
    public static String getMonthFirstDay(String date) {
        if (StringUtil.isNotBlank(date)) {
            DateTime dateTime = DateTimeFormat.forPattern(YYYY_MM_DD_HH_MM_SS).parseDateTime(date);
            return dateTime.dayOfMonth().withMinimumValue().toString(YYYY_MM_DD_HH_MM_SS);
        }
        return null;
    }


    /**
     * 获取本月第一天
     *
     * @param date
     * @return
     */
    public static Date getMonthFirstDays(String date) {
        DateTime dateTime = DateTimeFormat.forPattern(YYYY_MM).parseDateTime(date);
        return dateTime.dayOfMonth().withMinimumValue().toDate();
    }

    public static Date getMonthFirstDaysYYYYMM(String date) {
        DateTime dateTime = DateTimeFormat.forPattern(YYYYMM).parseDateTime(date);
        return dateTime.dayOfMonth().withMinimumValue().toDate();
    }

    public static Date getMonthFirstDays(String date, String pattern) {
        DateTime dateTime = DateTimeFormat.forPattern(pattern).parseDateTime(date);
        return dateTime.dayOfMonth().withMinimumValue().toDate();
    }


    /**
     * 获取本月最后一天
     *
     * @param date
     * @return
     */
    public static Date getMonthLastDays(String date) {
        DateTime dateTime = DateTimeFormat.forPattern(YYYY_MM).parseDateTime(date);
        return dateTime.dayOfMonth().withMaximumValue().toDate();
    }


    public static Date getMonthLastDays(String date, String pattern) {
        DateTime dateTime = DateTimeFormat.forPattern(pattern).parseDateTime(date);
        return dateTime.dayOfMonth().withMaximumValue().toDate();
    }


    /**
     * 获取本月第一天
     *
     * @return
     */
    public static String getCurrMonthFirstDay() {
        DateTime dateTime = DateTime.now();
        return dateTime.dayOfMonth().withMinimumValue().toString(YYYYMMDD);
    }

    /**
     * 获取指定日期的第一天
     *
     * @param date
     * @return
     */
    public static Date getMonthFirstDay(Date date) {
        Calendar cale = Calendar.getInstance();
        cale.setTime(date);
        cale.add(Calendar.MONTH, 0);
        cale.set(Calendar.DAY_OF_MONTH, 1);
        return cale.getTime();
    }

    /**
     * 获取当前月的最后一天
     *
     * @return
     */
    public static Date getMonthLastday(Date date) {
        Calendar cale = Calendar.getInstance();
        cale.setTime(date);
        cale.add(Calendar.MONTH, 1);
        cale.set(Calendar.DAY_OF_MONTH, 0);
        return cale.getTime();
    }


    /**
     * 获取本周第一天
     *
     * @param parttern
     * @return
     */
    public static String getWeekFirstday(String parttern) {
        DateTime now = DateTime.now();
        DateTime monday = now.withDayOfWeek(1)
                .withHourOfDay(0)
                .withMinuteOfHour(0)
                .withSecondOfMinute(0);
        return monday.toString(parttern);
    }


    /**
     * 格式化日期  yyyyMMdd 转 yyyy-MM-dd
     *
     * @param countDate
     * @return
     */
    public static String parseDay(String countDate) {
        int length = countDate.length();
        StringBuffer timeStringBuffer = new StringBuffer();
        timeStringBuffer.append(countDate.substring(0, length - 4)).append("-");
        timeStringBuffer.append(countDate.substring(length - 4, length - 2)).append("-");
        timeStringBuffer.append(countDate.substring(length - 2));
        return timeStringBuffer.toString();
    }

    /**
     * 日期格式化
     *
     * @param date yyyyMMdd
     * @return
     */
    public static Date parseDate(String date) {
        DateTime dateTime = null;
        if (StringUtil.isNotBlank(date)) {
            dateTime = DateTimeFormat.forPattern(YYYYMMDD).parseDateTime(date);
            return dateTime.toDate();
        }
        return null;
    }


    /**
     * 日期格式化
     *
     * @param date
     * @param format
     * @return
     */
    public static Date parseDate(String date, String format) {
        DateTime dateTime = null;
        if (StringUtil.isNotBlank(date)) {
            dateTime = DateTimeFormat.forPattern(format).parseDateTime(date);
            return dateTime.toDate();
        }
        return null;
    }

    /**
     * 获取当前系统时间
     *
     * @return
     */
    public static String getCurDay() {
        // 初始化时间
        DateTime dateTime = new DateTime();
        return dateTime.toString(YYYYMMDD);
    }

    public static String getCurDay_YYYYY_MM_DD() {
        // 初始化时间
        DateTime dateTime = new DateTime();
        return dateTime.toString(YYYY_MM_DD);
    }


    /**
     * 获取当天开始时间
     * @return
     */
    public static Date geCurDayStartTime(){
        // 初始化时间
        DateTime dateTime = new DateTime();
        String dateStr = dateTime.toString(YYYYMMDD);
        return parseDate(dateStr+"000000",YYYYMMDDHHMMSS);
    }

    /**
     * 获取当天结束时间
     * @return
     */
    public static Date geCurDayEndTime(){
        // 初始化时间
        DateTime dateTime = new DateTime();
        String dateStr = dateTime.toString(YYYYMMDD);
        return parseDate(dateStr+"235959",YYYYMMDDHHMMSS);
    }

    /**
     * 获取当前系统时间的年月
     *
     * @return
     */
    public static String getCurSysMonth() {

        // 初始化时间
        DateTime dateTime = new DateTime();
        return dateTime.toString(YYYYMM);
    }

    public static Date getCurSysMonthTime() {

        // 初始化时间
        DateTime dateTime = new DateTime();
        String dateStr = dateTime.toString(YYYYMM);
        return parseDate(dateStr+"01000000",YYYYMMDDHHMMSS);
    }


    public static String getCurSysMonthForPattern(String pattern) {

        // 初始化时间
        DateTime dateTime = new DateTime();
        return dateTime.toString(pattern);
    }

    /**
     * 获取某个月的天数
     *
     * @param year
     * @param month
     * @return
     */
    public static int daysOfMonth(int year, int month) {
        DateTime dateTime = new DateTime(year, month, 14, 12, 0, 0, 000);
        return dateTime.dayOfMonth().getMaximumValue();
    }

    /**
     * 获取当天开始时间
     *
     * @return
     */
    public static Date getCurBegin() {
        return parseDate(format(new Date(), YYYY_MM_DD) + " 00:00:00", YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 获取当天结束时间
     *
     * @return
     */
    public static Date getCurEnd() {
        return parseDate(format(new Date(), YYYY_MM_DD) + " 23:59:59", YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 获取本周开始时间
     *
     * @return
     */
    public static Date getWeekBegin() {
        return parseDate(getWeekFirstday(YYYY_MM_DD_HH_MM_SS), YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 获取本周结束时间
     *
     * @return
     */
    public static Date getWeekEnd() {
        return parseDate(format(plusDays(getWeekBegin(), 6), YYYY_MM_DD) + " 23:59:59", YYYY_MM_DD_HH_MM_SS);
    }


    /**
     * 获取上一周周开始时间
     *
     * @return
     */
    public static Date getLastWeekBegin() {
        return minusDays(getWeekBegin(), 7);
    }

    /**
     * 获取上一周结束时间
     *
     * @return
     */
    public static Date getLastWeekEnd() {
        return minusDays(getWeekEnd(), 7);
    }

    /**
     * 获取本月开始时间
     * @return String
     * **/
    public static Date getMonthBegin(){
        Calendar cal=Calendar.getInstance();
        cal.add(Calendar.MONTH, 0);
        cal.set(Calendar.DAY_OF_MONTH, 1);
        return parseDate(format(cal.getTime(), YYYY_MM_DD) + " 00:00:00", YYYY_MM_DD_HH_MM_SS);
    }
    /**
     * 获取本月最后时间
     * @return String
     * **/
    public static Date getMonthEnd(){
        Calendar cal=Calendar.getInstance();
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        return parseDate(format(cal.getTime(), YYYY_MM_DD) + " 23:59:59", YYYY_MM_DD_HH_MM_SS);
    }


    /**
     * 获取本季度第一天
     */
    public static Date getQuarterBegin() {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        int month = calendar.get(Calendar.MONTH);
        int quarter = month / 3 + 1;
        int startMonth = 1;
        if (quarter == 2) {
            startMonth = 4;
        } else if (quarter == 3) {
            startMonth = 7;
        } else if (quarter == 4) {
            startMonth = 10;
        }
        calendar.set(Calendar.MONTH, startMonth - 1);
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        return parseDate(format(calendar.getTime(), YYYY_MM_DD) + " 00:00:00", YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 当前季度结束时间
     *
     * @return Date
     */
    public static Date getQuarterEnd() {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        int month = calendar.get(Calendar.MONTH);
        int quarter = month / 3 + 1;
        int endMonth = 3;
        if (quarter == 2) {
            endMonth = 6;
        } else if (quarter == 3) {
            endMonth = 9;
        } else if (quarter == 4) {
            endMonth = 12;
        }
        calendar.set(Calendar.MONTH, endMonth - 1);
        int lastDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        calendar.set(Calendar.DAY_OF_MONTH, lastDay);
        return parseDate(format(calendar.getTime(), YYYY_MM_DD) + " 23:59:59", YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 获取本年的开始时间
     *
     * @return String
     **/
    public static Date getYearBegin() {
        return parseDate(format(new Date(), "yyyy") + "-01-01 00:00:00", YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 获取本年的结束时间
     *
     * @return String
     **/
    public static Date getYearEnd() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.MONTH, calendar.getActualMaximum(Calendar.MONTH));
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
        Date currYearLast = calendar.getTime();
        return parseDate(format(currYearLast, YYYY_MM_DD) + " 23:59:59", YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 时间戳转化为日期
     * @param timestamp
     * @return
     */
    public static String timestampToDate(long timestamp) {
        SimpleDateFormat sdf = new SimpleDateFormat(YYYY_MM_DD_HH_MM_SS);
        return sdf.format(new Date(Long.valueOf(timestamp)));
    }

    public static String begin(String time, String format) {
        return format(parseDate(time, format), YYYY_MM_DD) + " 00:00:00";
    }

    public static String end(String time, String format) {
        return format(parseDate(time, format), YYYY_MM_DD) + " 23:59:59";
    }

    //精确时间到小时
    public static Date accurateToHour(Date time) {
        return parseDate(format(time, YYYY_MM_DD_HH) + ":00:00", YYYY_MM_DD_HH_MM_SS);
    }

    //精确时间到小时
    public static Date getDatEnd(Date time) {
        return parseDate(format(time, YYYY_MM_DD) + " 23:59:59", YYYY_MM_DD_HH_MM_SS);
    }


    /**
     * 判断当前时间是否为周末价格
     * @param date
     * @return
     */
    public static boolean isWeek(Date date){


        return false;
    }

    public static Date convertString2Date(String format, String dateStr) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
        try {
            Date date = simpleDateFormat.parse(dateStr);
            return date;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 把某一个时间段按照天拆分
     * @param startDate
     * @param endDate
     * @return
     */
    public static List<String> getIntervalDayList(Date startDate,Date endDate){
        List<String> result = new ArrayList<>();
        while(startDate.getTime() <= endDate.getTime()){
            result.add(format(startDate,YYYY_MM_DD));
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(startDate);
            calendar.add(Calendar.HOUR,24);
            startDate = calendar.getTime();
        }
        return result;
    }



    public static List<String> getIntervalTimeList(Date startDate,Date endDate){
        List<String> result = new ArrayList<>();
        while(startDate.getTime() <= endDate.getTime()){
            result.add(format(startDate,"HH:mm"));
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(startDate);
            calendar.add(Calendar.MINUTE,30);
            startDate = calendar.getTime();
        }
        return result;
    }


    public static String transTime(Date startTime) {
        if(startTime == null){
            return null;
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(startTime);
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append(calendar.get(Calendar.MONTH) + 1);
        stringBuffer.append("月");
        stringBuffer.append(calendar.get(Calendar.DAY_OF_MONTH));
        stringBuffer.append("日");
        stringBuffer.append("（");
        stringBuffer.append(weekMap.get(calendar.get(Calendar.DAY_OF_WEEK) - 1));
        stringBuffer.append("）");
        stringBuffer.append(DateTimeUtils.format(startTime,DateTimeUtils.HHMM));
        return stringBuffer.toString();
    }

    public static void main(String[] args) {
        Date data1 = new Date();
        Date date2 = DateTimeUtils.parseDate("20250617");
        System.out.println(secondsBetween(data1,date2));

    }

}
